/*M///////////////////////////////////////////////////////////////////////////////////////
//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                        Intel License Agreement
//                For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of Intel Corporation may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/

#include "precomp.hpp"

#ifdef HAVE_VIDEOINPUT
#include "videoinput.h"

/********************* Capturing video from camera via VFW *********************/

class CvCaptureCAM_DShow : public CvCapture {
public:
    CvCaptureCAM_DShow();
    virtual ~CvCaptureCAM_DShow() { close(); }

    virtual bool open(int index);
    virtual void close();
    virtual double getProperty(int);
    virtual bool setProperty(int, double);
    virtual bool grabFrame();
    virtual IplImage* retrieveFrame(int);
    virtual int getCaptureDomain() { return CV_CAP_DSHOW; } // Return the type of the capture object: CV_CAP_VFW, etc...

protected:
    void init();

    int index;
    IplImage* frame;
    static videoInput VI;
};


struct SuppressVideoInputMessages {
    SuppressVideoInputMessages() { videoInput::setVerbose(false); }
};

static SuppressVideoInputMessages do_it;
videoInput CvCaptureCAM_DShow::VI;

CvCaptureCAM_DShow::CvCaptureCAM_DShow() {
    index = -1;
    frame = 0;
}

void CvCaptureCAM_DShow::close() {
    if (index >= 0) {
        VI.stopDevice(index);
        index = -1;
        cvReleaseImage(&frame);
    }
}

// Initialize camera input
bool CvCaptureCAM_DShow::open(int _index) {
    int try_index = _index;
    int devices = 0;

    close();
    devices = VI.listDevices(true);
    if (devices == 0) {
        return false;
    }
    try_index = try_index < 0 ? 0 : (try_index > devices - 1 ? devices - 1 : try_index);
    VI.setupDevice(try_index);
    if (!VI.isDeviceSetup(try_index)) {
        return false;
    }
    index = try_index;
    return true;
}

bool CvCaptureCAM_DShow::grabFrame() {
    return true;
}


IplImage* CvCaptureCAM_DShow::retrieveFrame(int) {
    if (!frame || VI.getWidth(index) != frame->width || VI.getHeight(index) != frame->height) {
        if (frame) {
            cvReleaseImage(&frame);
        }
        int w = VI.getWidth(index), h = VI.getHeight(index);
        frame = cvCreateImage(cvSize(w, h), 8, 3);
    }

    VI.getPixels(index, (uchar*)frame->imageData, false, true);
    return frame;
}

double CvCaptureCAM_DShow::getProperty(int property_id) {
    switch (property_id) {
    case CV_CAP_PROP_FRAME_WIDTH:
        return VI.getWidth(index);
    case CV_CAP_PROP_FRAME_HEIGHT:
        return VI.getHeight(index);
    case CV_CAP_PROP_FOURCC:
        return 0;
    }
    return 0;
}

bool CvCaptureCAM_DShow::setProperty(int property_id, double value) {
    int width = 0, height = 0;

    switch (property_id) {
    case CV_CAP_PROP_FRAME_WIDTH:
        width = cvRound(value);
        height = width * 3 / 4;
        break;
    case CV_CAP_PROP_FRAME_HEIGHT:
        height = cvRound(value);
        width = height * 4 / 3;
    default:
        return false;
    }

    if (width != VI.getWidth(index) || height != VI.getHeight(index)) {
        VI.stopDevice(index);
        VI.setupDevice(index, width, height);
    }
    return VI.isDeviceSetup(index);
}


CvCapture* cvCreateCameraCapture_DShow(int index) {
    CvCaptureCAM_DShow* capture = new CvCaptureCAM_DShow;

    if (capture->open(index)) {
        return capture;
    }

    delete capture;
    return 0;
}

#ifdef _MSC_VER
#pragma comment(lib, "videoInput.lib")
#endif

#endif
